#include "stm32f4xx.h"                  // Device header
#include "I2C_Init.h"
#include "delay.h"
#include "exit.h"

// static void I2C_GPIO_Config(void)
// {
// GPIO_InitTypeDef GPIO_InitStructure;
// 
// /*使能 I2C 外设时钟 */
// RCC_APB1PeriphClockCmd(DS3231_I2C_CLK, ENABLE);
// 
// /*使能 I2C 引脚的 GPIO 时钟*/
// RCC_AHB1PeriphClockCmd(DS3231_I2C_SCL_GPIO_CLK |
// DS3231_I2C_SDA_GPIO_CLK, ENABLE);
// 
// /* 连接引脚源 PXx 到 I2C_SCL*/
// GPIO_PinAFConfig(DS3231_I2C_SCL_GPIO_PORT, DS3231_I2C_SCL_SOURCE,
// DS3231_I2C_SCL_AF);
// /* 连接引脚源 PXx 到 to I2C_SDA*/
// GPIO_PinAFConfig(DS3231_I2C_SDA_GPIO_PORT, DS3231_I2C_SDA_SOURCE,
// DS3231_I2C_SDA_AF);
// 
// /*配置 SCL 引脚 */
// GPIO_InitStructure.GPIO_Pin =DS3231_I2C_SCL_PIN;
// GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
// GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
// GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
// GPIO_Init(DS3231_I2C_SCL_GPIO_PORT, &GPIO_InitStructure);
// /*配置 SDA 引脚 */
// GPIO_InitStructure.GPIO_Pin = DS3231_I2C_SDA_PIN;
// GPIO_Init(DS3231_I2C_SDA_GPIO_PORT, &GPIO_InitStructure);
// 
// GPIO_SetBits(GPIOF,GPIO_Pin_0);
// GPIO_SetBits(GPIOF,GPIO_Pin_1);
// 
// }
 
//static void I2C_Mode_Config(void)
// {
//	I2C_InitTypeDef I2C_InitStructure;
// 
//   //在接收到一个字节后返回一个应答ACK

//	 /* I2C 配置 */
//	 /*I2C 模式*/
//	 I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
//	 /*占空比*/
//	 I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
//	 /*I2C 自身地址*/
//	 I2C_InitStructure.I2C_OwnAddress1 =I2C_OWN_ADDRESS7;
//	 /*使能响应*/
//	 I2C_InitStructure.I2C_Ack = I2C_Ack_Enable ;
//	 /* I2C 的寻址模式 */
//	 I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
//	 /* 通信速率 */
//	 I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;
//	 /*写入配置*/
//	 I2C_Init(DS3231_I2C, &I2C_InitStructure);
//	 /* 使能 I2C */
//	 I2C_Cmd(DS3231_I2C, ENABLE);
// }

/***********************************
 * I2C总线初始化
 * *********************************/
//void I2C2_Init(void)
//{

////    P3DIR |= BIT1;                  // P3.1  I2C_SDA
////    P3OUT |= BIT1;                  // P3.1 = 1 释放I2C总线的数据线

////    P3DIR |= BIT2;                  // P3.2  I2C_SCL
////    P3OUT |= BIT2;                  // P3.2 = 1 释放I2C总线的时钟线

////    P1DIR &= ~BIT2;                 // P1.2  DS3231_INT/SQW
//	// 1. 使能GPIOF的时钟
//    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
//    GPIO_InitTypeDef GPIO_InitStruct;
//    // 2. 初始化GPIO结构体
//    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
//    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;     
//    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;    // 推挽输出
//    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;  // 输出速度
//    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;   // 不设置上拉/下拉
//    // 3. 初始化GPIOF的PF0引脚
//    GPIO_Init(GPIOF, &GPIO_InitStruct);
//	GPIO_SetBits(GPIOF,GPIO_Pin_0);
//	
//	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
//	GPIO_Init(GPIOF, &GPIO_InitStruct);
//	GPIO_SetBits(GPIOF,GPIO_Pin_1);
//	
//	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
//	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2;
//	GPIO_Init(GPIOA, &GPIO_InitStruct);
//}
// 
// 

 //最后读取到的时间数据将赋值到下面这几个变量
u8 RTC_Sec,RTC_Min,RTC_Hour,RTC_Week,RTC_Date,RTC_Month;   
u16 RTC_Year;


void IIC2_SoftInit(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0 | GPIO_Pin_1; 			//10--SCL   11--SDA；PB10 PB11
    GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_OUT;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;			//OD开漏
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;			//上拉
    GPIO_Init(GPIOF, &GPIO_InitStructure);
}

/******* 设置SDA为输出*******/
 
void SDA_OUT(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin= GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_OUT;	//推挽输出
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;			//OD开漏
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;			//上拉
    GPIO_Init(GPIOF, &GPIO_InitStructure);
}


/******* 设置SDA为输入*******/
 
void SDA_IN(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin= GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN;		//上拉输入
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;			//OD开漏
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;			//上拉
	GPIO_Init(GPIOF, &GPIO_InitStructure);
}


 void IIC_Start(void)			//起始信号
{
    SDA_OUT();			//把SDA作为输出，初始化为推挽输出
    IIC_SDA_H();		//SDA输出高电平
    IIC_SCL_H();		//SCL输出高电平
    delay_us(20);
    IIC_SDA_L();		//SDA输出低点评
    delay_us(2);
    IIC_SCL_L();		//SCL输出低电平
    delay_us(20);
}


void IIC_Stop(void)		//停止信号
{
    IIC_SCL_H();		//SCL输出高电平
    IIC_SDA_L();		//SDA输出低点评
    delay_us(20);
    IIC_SDA_H();		//SDA输出高电平
    delay_us(20);
}

u8 IIC_Wait_Ask(void)		//等待应答信号
{
    u8 count;
    IIC_SDA_H();
	delay_us(20);
	SDA_IN();
	delay_us(20);
    IIC_SCL_H();
    delay_us(20);
    while(Read_IIC_SDA)
    {
        count++;
        if(count>250)
        {
            IIC_Stop();				//如果长时间无应答，则认为从站故障，终止数据传输，并返回1
            return 1;
        }   
    }
    IIC_SCL_L();
    delay_us(1);
    return 0;
}


void IIC_Ack(void)		//应答信号
{
    IIC_SCL_L();
    SDA_OUT();
    IIC_SDA_L();
    delay_us(20);
    IIC_SCL_H();
    delay_us(20);
    IIC_SCL_L();
}

void IIC_NAck(void)		//主机不产生应答信号NACK
{
    IIC_SCL_L();
    SDA_OUT();
    IIC_SDA_H();
    delay_us(20);
    IIC_SCL_H();
    delay_us(20);
    IIC_SCL_L();
}


void IIC_WriteByte(u8 data)			//写1Byte数据，每个数据都是以写1Byte作为基本单位
{
    u8 i;
    SDA_OUT();						//SDA切换到数据输出模式
	delay_us(20);
    for(i=0;i<8;i++)				//循环传输1Byte数据，即8bit
    {
        IIC_SCL_L();				//SCL置低电平，为下个Bit数据做准备
		delay_us(2);
        if(data & 0x80)     		//MSB,如果date的第八位为1
		{
            IIC_SDA_H();			//则SDA置高
		}
        else
		{
            IIC_SDA_L();			//否则置低
		}
		delay_us(10);
        IIC_SCL_H();				//SCL拉高，产生一个时钟信号，从机读取SDA状态
        delay_us(20);				//延时，丛机在这段时间读取SDA状态
        IIC_SCL_L();				//延时后拉低SCL，为下个Bit数据做准备
        data<<=1;					//date左移1位，下一bit变成第八位
    }
}


//读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
 
 
 
u8 IIC_Read_Byte(const unsigned char ack)
{
	u8 i,receive=0;
	SDA_IN();			//SDA设置为输入
	delay_us(20);
    for(i=0;i<8;i++ )
	{
		IIC_SCL_L(); 
		delay_us(20);
		IIC_SCL_H();
        receive<<=1;
		delay_us(20);
        if(Read_IIC_SDA)
			receive++;   
		delay_us(20); 
    }					 
    if (!ack)
	{
        IIC_NAck();		//发送nACK
	}
    else
	{
        IIC_Ack();		 //发送ACK   
	}
    return receive;
}

void I2C_single_byte_write(unsigned char Waddr, unsigned char Data)
{
	IIC_Start();		//起始信号
	IIC_WriteByte(0xd0);		//DS3231设备地址，写
	IIC_Wait_Ask();				//等待应答
	IIC_WriteByte(Waddr);	//寄存器地址
	IIC_Wait_Ask();				//等待应答
	IIC_WriteByte(Data);		//写入数据
	IIC_Wait_Ask();				//等待应答
	IIC_Stop();					//结束信号
}

unsigned char I2C_single_byte_read(unsigned char Waddr)
{
	u8 data = 0;
	IIC_Start();										//产生起始位
	IIC_WriteByte(0xd0); 				//发送从机地址（写模式D0）
	IIC_Wait_Ask();				//等待应答
	IIC_WriteByte(Waddr);							//发送寄存器地址
	IIC_Wait_Ask();				//等待应答
	IIC_Start();										//重复起始信号
	IIC_WriteByte(0xd1);		//发送从机地址（读模式）
	IIC_Wait_Ask();							//等待应答
	data = IIC_Read_Byte(0);				//读取数据，参数设为0 --- NACK
	IIC_Stop();
	return data;
}


//void IIC_DS3231_ReadAll(void)		//读取所有时间数据并转换
//{
//	u8 Data_Sec,Data_Min,Data_Hour,Data_Week,Data_Date,Data_Month,Data_Year;
//	u8 Low,High;
//	
//	Data_Sec= IIC_DS3231_ByteRead(DS3231_SEC);			//读取数据秒
//	Data_Min = IIC_DS3231_ByteRead(DS3231_MIN);			//读取数据分
//	Data_Hour = IIC_DS3231_ByteRead(DS3231_HOUR);		//读取数据时
//	Data_Week = IIC_DS3231_ByteRead(DS3231_WEEK);		//读取数据周
//	Data_Date = IIC_DS3231_ByteRead(DS3231_DATE);			//读取数据日
//	Data_Month = IIC_DS3231_ByteRead(DS3231_MONTH);		//读取数据月
//	Data_Year = IIC_DS3231_ByteRead(DS3231_YEAR);		//读取数据年
//	
//	Low=Data_Sec&0x0f;						//取低四位
//	High=(( Data_Sec& 0xf0) >> 4);			//取高四位
//	RTC_Sec=High*10+Low;					//转换秒（高四位*10+低四位）
//	
//	Low=Data_Min&0x0f;
//	High=(( Data_Min& 0xf0) >> 4);
//	RTC_Min=High*10+Low;					//转换分
//	
//	Low=Data_Hour&0x0f;
//	High=(( Data_Hour& 0x30) >> 4);
//	RTC_Hour=High*10+Low;					//转换时（高两位*10+低四位）
// 
//	RTC_Week=Data_Week;						//转换周（不需要转换）
//	
//	Low=Data_Date&0x0f;
//	High=(( Data_Date& 0xf0) >> 4);
//	RTC_Date=High*10+Low;					//转换日
//	
//	Low=Data_Month&0x0f;
//	High=(( Data_Month& 0x10) >> 4);
//	RTC_Month=High*10+Low;					//转换月
//	
//	Low=Data_Year&0x0f;
//	High=(( Data_Year& 0xf0) >> 4);
//	RTC_Year=((Data_Month>>7)+20)*100+High*10+Low;	//转换年(世纪*100+高四位*10+低四位)		
//}

//void IIC_DS3231_WriteAll(u16 Year,u8 Month,u8 Date,u8 Week,u8 Hour,u8 Min,u8 Sec)
//{	
//	u8 Sec_Date,Min_Date,Hour_Date,Week_Date,Date_Date,Month_Date,Year_Date;
//	u8 H_Bit,L_Bit;
//	
//	H_Bit=(Sec/10)<<4;			//取高四位
//	L_Bit=Sec%10;				//取低四位
//	Sec_Date=H_Bit|L_Bit;		//合并成八位
//	
//	H_Bit=(Min/10)<<4;
//	L_Bit=Min%10;
//	Min_Date=H_Bit|L_Bit;
//	
//	H_Bit=Hour/10;
//	L_Bit=Hour%10;
//	Hour_Date=(H_Bit<<4)|L_Bit;
//		
//	Week_Date=Week;
//	
//	H_Bit=Date/10;
//	L_Bit=Date%10;
//	Date_Date=(H_Bit<<4)|L_Bit;
//	
//	if(Year/100==20)
//	{	
//		H_Bit=Month/10;
//		L_Bit=Month%10;
//		Month_Date=(H_Bit<<4)|L_Bit;
//		
//		H_Bit=(Year-2000)/10;
//		L_Bit=(Year-2000)%10;
//		Year_Date=(H_Bit<<4)|L_Bit;
//		
//	}
//	else
//	{
//		H_Bit=Month/10+8;		//05h第8位如果是1，则为22世纪
//		L_Bit=Month%10;
//		Month_Date=(H_Bit<<4)|L_Bit;
//		
//		H_Bit=(Year-2100)/10;
//		L_Bit=(Year-2100)%10;
//		Year_Date=(H_Bit<<4)|L_Bit;
//	}
//	IIC_DS3231_ByteWrite(DS3231_YEAR,Year_Date);	
//	IIC_DS3231_ByteWrite(DS3231_MONTH,Month_Date);
//	IIC_DS3231_ByteWrite(DS3231_DATE,Date_Date);
//	IIC_DS3231_ByteWrite(DS3231_WEEK,Week_Date);
//	IIC_DS3231_ByteWrite(DS3231_HOUR,Hour_Date);
//	IIC_DS3231_ByteWrite(DS3231_MIN,Min_Date);
//	IIC_DS3231_ByteWrite(DS3231_SEC,Sec_Date);
//	
//}




 /**
 * @brief I2C 外设初始化
 * @param 无
 * @retval 无
 */
 void I2C_EE_Init(void)
 {
	//I2C_GPIO_Config();
	 //I2C2_Init();
 
	//I2C_Mode_Config();
	IIC2_SoftInit(); 
	 
	EXTI_DS3231_Config();
 }
//// void I2cByteWrite(uint8_t addr, uint8_t data)
////{
//////		I2C_AcknowledgeConfig(I2C2,ENABLE); //使能应答
////		I2C_GenerateSTART(I2C2,ENABLE); //发送一个开始位
////			
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_MODE_SELECT));//等待EV5
////		I2C_Send7bitAddress(I2C2,0xd0,I2C_Direction_Transmitter); //发送从地址
////			
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)); //等待EV6
////		I2C_SendData(I2C2,addr); //发送要写入数据的地址
////			
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_BYTE_TRANSMITTING));//等待EV8
////		I2C_SendData(I2C2,data); //发送要写入的数据
////			
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_BYTE_TRANSMITTED));//等待EV8_2
////		I2C_GenerateSTOP(I2C2,ENABLE); //发送停止位
////}
//// uint8_t I2cByteRead(uint8_t nAddr)
////{
////		I2C_AcknowledgeConfig(I2C2,ENABLE); //使能应答
////		I2C_GenerateSTART(I2C2,ENABLE); //发送一个开始位
////		
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_MODE_SELECT)){;} //等待EV5
////		I2C_Send7bitAddress(I2C2,0xd0,I2C_Direction_Transmitter); //发送一个伪写指令
////		
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)){;}//等待EV6
////		I2C_SendData(I2C2,nAddr);//发送读地址
////		
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_BYTE_TRANSMITTED)){;} //等待EV8
////		I2C_GenerateSTART(I2C2,ENABLE); //发送一个开始位
////		
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_MODE_SELECT)){;} //等待EV5
////		I2C_Send7bitAddress(I2C2,0xd0,I2C_Direction_Receiver); //发送一个读指令
////		
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)){;} //等待EV6
////		I2C_AcknowledgeConfig(I2C2,DISABLE); //应答使能关闭
////		I2C_GenerateSTOP(I2C2,ENABLE); //发送一个停止位
////		
////		while(!I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_BYTE_RECEIVED)){;} //等待EV7
////		return I2C_ReceiveData(I2C2); //返回读到的数据
////}

/***********************************
 * I2C总线产生起始信号
 * *********************************/
//void I2C_START(void)
//{
//    //P3OUT |= BIT1;                  // P2.5 = 1 拉高I2C总线的数据线
//	GPIO_SetBits(GPIOF,GPIO_Pin_0);
//    delay_us(20);
//    //P3OUT |= BIT2;                  // P5.7 = 1 拉高I2C总线的时钟线
//	GPIO_SetBits(GPIOF,GPIO_Pin_1);
//    delay_us(20);
//    //P3OUT &=~BIT1;                  // 在时钟线SCL为高时，拉低数据线SDA，产生起始信号
//	GPIO_ResetBits(GPIOF,GPIO_Pin_0);
//    delay_us(20);
//    //P3OUT &=~BIT2;                  // 拉低时钟线SCL,准备收发数据，总线处于忙状态
//	GPIO_ResetBits(GPIOF,GPIO_Pin_1);
//    delay_us(20);
//}

/***********************************
 * I2C总线产生停止信号
 * *********************************/
//void I2C_STOP(void)
//{
//    //P3OUT &=~BIT1;                  // 拉低数据线SDA
//	GPIO_ResetBits(GPIOF,GPIO_Pin_0);
//    delay_us(20);
//    //P3OUT |= BIT2;                  // 拉高时钟线SCL
//	GPIO_SetBits(GPIOF,GPIO_Pin_1);
//    delay_us(20);
//    //P3OUT |= BIT1;                  // 在时钟线SCL为高时，拉高数据线SDA，产生停止信号
//	GPIO_SetBits(GPIOF,GPIO_Pin_0);
//    delay_us(20);
//}

/***********************************
 * 接收应答信号函数
 * *********************************/
//void I2C_Tack(void)
//{
//    P3OUT &=~BIT1;
//    P3DIR &=~BIT1;                  // P3.1设置为输入，准备接收应答信号
	
//   // 1. 使能GPIOF的时钟
//    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
//    GPIO_InitTypeDef GPIO_InitStruct;
//    // 2. 初始化GPIO结构体
//    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
//    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;      // 输入模式
//    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;    // 推挽输出
//    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;  // 输出速度
//    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;   // 不设置上拉/下拉
//    // 3. 初始化GPIOF的PF0引脚
//    GPIO_Init(GPIOF, &GPIO_InitStruct);
//	
//	GPIO_ResetBits(GPIOF,GPIO_Pin_0);
//	
//    delay_us(20);
//    //P3OUT |= BIT2;                  // 拉高时钟线SCL
//	GPIO_SetBits(GPIOF,GPIO_Pin_1);
//    delay_us(20);
//	
//    //P3DIR &=~BIT1;                  // P3.1设置为输入，准备接收应答信号
//	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
//    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;      // 输入模式
//	GPIO_Init(GPIOF, &GPIO_InitStruct);

//    while(GPIO_ReadInputDataBit(GPIOF,0)==1);        //等待第9个周期从机发送ACK信号“0”
//	
//    //P3DIR |= BIT1;                  // P3.1  I2C_SDA
//    //P3OUT &=~BIT2;                  // 拉低时钟线SCL
//	
//	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
//	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT; 
//	GPIO_Init(GPIOF, &GPIO_InitStruct);
//	
//	GPIO_ResetBits(GPIOF,GPIO_Pin_1);
//	
//    delay_us(20);
//}

/***********************************
 * 产生非应答信号函数
 * *********************************/
//void I2C_NOACK(void)
//{
//    //P3OUT |= BIT1;                  // P3.1 = 1 拉高I2C总线的数据线
//	GPIO_SetBits(GPIOF,GPIO_Pin_0);
//    delay_us(20);
//    //P3OUT |= BIT2;                  // P3.2 = 1 拉高I2C总线的时钟线
//	GPIO_SetBits(GPIOF,GPIO_Pin_1);
//    delay_us(20);
//    //P3OUT &=~BIT2;                  // 拉低时钟线SCL
//	GPIO_ResetBits(GPIOF,GPIO_Pin_1);
//    delay_us(20);

//}

/***********************************
 * 向I2C写入一个字节的数据
 * *********************************/
//void I2C_write_byte(unsigned char Data)
//{
//    unsigned char i;
//    for(i = 0; i < 8; i++)          // 有8位数据
//    {
//        if (Data & 0x80)            // 取出最高位
//		{
//            //P3OUT |= BIT1;
//			GPIO_SetBits(GPIOF,GPIO_Pin_0);
//		}
//        else
//		{
//            //P3OUT &=~BIT1;
//			GPIO_ResetBits(GPIOF,GPIO_Pin_0);
//		}
//        delay_us(20);
//        //P3OUT |= BIT2;              // 拉高时钟线SCL，将数写入到设备中
//		GPIO_SetBits(GPIOF,GPIO_Pin_1);
//        delay_us(20);
//        //P3OUT &=~BIT2;              // 拉低时钟线SCL，允许改变数据线的状态
//		GPIO_ResetBits(GPIOF,GPIO_Pin_1);
//        delay_us(20);
//        Data <<= 1;                 //数据左移为下一次取最高位做准备
//    }
//    I2C_Tack();
//    delay_us(1000);
//}

/***********************************
 * 从I2C读取一个字节的数据
 * *********************************/
//unsigned char I2C_read_byte()
//{
//    unsigned char i;
//    unsigned char Data = 0;             // 定义一个缓冲寄存器
//	
//    //P3DIR &=~BIT1;                  // P3.1设置为输入，准备接收数据
//	// 1. 使能GPIOF的时钟
//    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
//    GPIO_InitTypeDef GPIO_InitStruct;
//    // 2. 初始化GPIO结构体
//    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
//    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;      // 输入模式
//    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;    // 推挽输出
//    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;  // 输出速度
//    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;   // 不设置上拉/下拉
//    // 3. 初始化GPIOF的PF0引脚
//    GPIO_Init(GPIOF, &GPIO_InitStruct);
//	
//    delay_us(20);
//    for(i = 0; i < 8; i++)          // 有8位数据
//    {
//        //P3OUT |= BIT2;              // 拉高时钟线SCL，为读取下一位数据做准备
//		GPIO_SetBits(GPIOF,GPIO_Pin_1);
//        delay_us(20);

//        Data = Data << 1;                 // 将缓冲字节的数据左移一位，末位补零，准备读取数据
//        delay_us(20);
//        if(GPIO_ReadInputDataBit(GPIOF,0) == 1)
//            Data |= 0x01;           // 如果数据线为高电平，则给缓冲字节的最低位写1，如果数据线为低电平，则不操作，等待下次循环移位补零
//        //P3OUT &=~BIT2;              // 拉低时钟线SCL，允许改变数据线的状态
//		GPIO_ResetBits(GPIOF,GPIO_Pin_1);
//        delay_us(20);
//    }
//	
//    //P3DIR |= BIT1;                  // P3.1设置为输出
//	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
//	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT; 
//	GPIO_Init(GPIOF, &GPIO_InitStruct);
//	
//    return Data;                    // 返回读取的一个字节数据
//}

/***********************************
 * 向任意地址写入一个字节数据
 * *********************************/
//void I2C_single_byte_write(unsigned char Waddr, unsigned char Data)// 要操作的单元地址Waddr，要写入的数Data
//{
//    I2C_START();               // 产生起始信号
//    I2C_write_byte(0xd0);      // 写入设备地址（写）
//    I2C_write_byte(Waddr);     // 写入要操作的单元地址
//    I2C_write_byte(Data);      // 写入数据
//    I2C_STOP();                // 产生停止信号
//}

/***********************************
 * 从任意地址读取一个字节数据
 * *********************************/
//unsigned char I2C_single_byte_read(unsigned char Waddr)// 要操作的单元地址Waddr
//{
//    unsigned char Data;        // 定义一个缓冲寄存器
//    //先找到要操作的单元地址
//    I2C_START();               // 产生起始信号
//    I2C_write_byte(0xd0);      // 写入设备地址（写）
//    I2C_write_byte(Waddr);     // 写入要操作的单元地址
//    //开始读数
//    I2C_START();               // 产生起始信号
//    I2C_write_byte(0xd1);      // 写入设备地址（读）
//    Data = I2C_read_byte();    // 读取数据
//    I2C_NOACK();               // 主机产生非应答信号
//    I2C_STOP();                // 产生停止信号
//    return Data;               // 返回读取的一个字节数据
//}






